home *** CD-ROM | disk | FTP | other *** search
/ MacTech 1 to 12 / MacTech-vol-1-12.toast / Source / MacTech® Magazine / Volume 05 - 1989 / 05.08 Aug 89 / POOPDraw Code ƒ / PANL DrawPanel.c < prev    next >
Encoding:
C/C++ Source or Header  |  1989-06-12  |  16.5 KB  |  600 lines  |  [TEXT/KAHL]
  1. /********************************************************************/
  2. /*                        SOURCE CODE FILE                            */
  3. /********************************************************************/
  4. /*
  5. *   >>>    File name:        PANL DrawPanel.c    
  6. *
  7. *      >>>    Purpose:        Methods for Drawing
  8. *     >>>    Project:        PoopDraw    Version 1        
  9. *     >>>    Date:            6/10/89
  10. *      >>>    By:                Adam Treister
  11. *
  12. */
  13. /********************************************************************/
  14. /*    For Your Information            1802 Hillside Rd. SB CA 93101    */
  15. /********************************************************************/
  16.  
  17. #include "PoopDrawInc"
  18.  
  19. typedef struct
  20. {
  21.     _StdObjectFields
  22.  
  23.     ObjectHandle        objectList;                /* all objects in document  */
  24.     ObjectHandle        selectList;                /* the selected objects */
  25.     ObjectHandle        activeText;                /* active text object */
  26.     ObjectHandle        doc;                    /* the disk based document */
  27.  
  28.     Boolean                changed;                /* TRUE - The window contents have been changed */
  29.  
  30.     short                curTool;                /* The current Tool */
  31.     short                curPat;                    /* The current Pattern */
  32.     short                curWeight;                /* The current Line Weight */
  33.  
  34.     DrawStateRec        drawState;                /* draw state to give new objects */
  35.     int                 fileVol;                /* volume where current file lives */
  36.     short                displayScaling;            /* scaling factor for displayed objects */
  37.  
  38. } DrawPanelRec,*DrawPanelPtr,**DrawPanelHandle;
  39. /*------------------------------------------------------------------*/
  40.  
  41. DrawPanelDispatch(DrawPanelHandle ObjectH,int message,LPtr ParmP);
  42.  
  43.  
  44. private void Dispose(DrawPanelHandle ObjectH);
  45. private void Blink(DrawPanelHandle ObjectH);
  46. private void Ungroup(DrawPanelHandle ObjectH);
  47. private void Group(DrawPanelHandle ObjectH);
  48. private void BringForward(DrawPanelHandle ObjectH,ObjectHandle Obj);
  49. private void SendBack(DrawPanelHandle ObjectH,ObjectHandle Obj);
  50. private void MouseDown(DrawPanelHandle ObjectH);
  51. private void KeyDown(DrawPanelHandle ObjectH);
  52. private void Update(DrawPanelHandle ObjectH);
  53. private void Save(DrawPanelHandle ObjectH,LPtr ParmP);
  54. private void Load(DrawPanelHandle ObjectH,LPtr ParmP);
  55.  
  56. private void SetFill(DrawPanelHandle ObjectH,LPtr ParmP);
  57. private void SetPenPat(DrawPanelHandle ObjectH,LPtr ParmP);
  58. private void SetPenSize(DrawPanelHandle ObjectH,LPtr ParmP);
  59. void InitQDState(DrawStatePtr drawStateP);
  60. void DrawOutline(Rect r,int curTool);
  61. private void OutlineNewObject(DrawPanelHandle ObjectH,Point startPt, short curTool);
  62.  
  63. private void ClickInPalette(DrawPanelHandle ObjectH,Point pt);
  64. private void InvertPaletteRect(int tool);
  65. private void FramePaletteRect(int tool);
  66.  
  67. void DragActiveObjects(DrawPanelHandle ObjectH);
  68.  
  69. /********************************************************************/
  70.  
  71.  
  72. DrawPanelDispatch(ObjectH,message,ParmP)
  73. DrawPanelHandle ObjectH;
  74. int message;
  75. LPtr ParmP;
  76. {
  77.     switch (message)
  78.     {
  79.  
  80.         case DISPOSE:            Dispose(ObjectH);                        break;
  81.         case KEYDOWN:            KeyDown(ObjectH);                        break;
  82.         case MOUSEDOWN:            MouseDown(ObjectH);                        break;
  83.         case UPDATE:            Update(ObjectH);                        break;
  84.         case FILL:                SetFill(ObjectH,ParmP);                    break;
  85.         case PENPAT:            SetPenPat(ObjectH,ParmP);                break;
  86.         case PENSIZE:            SetPenSize(ObjectH,ParmP);                break;
  87.         case SAVE:                Save(ObjectH,ParmP);                    break;
  88.         case LOAD:                Load(ObjectH,ParmP);                    break;
  89.  
  90.          case GETDRAWSTATE:        *(DrawStatePtr)ParmP = (*ObjectH)->drawState;            break;
  91.         case GROUP:                Group(ObjectH);                            break;
  92.         case UNGROUP:            Ungroup(ObjectH);                        break;
  93.         
  94.  
  95.         case OPEN:                                                        break;
  96.  
  97.         case MOVE:                DragActiveObjects(ObjectH);                break;
  98.         case BRINGTOFRONT:        
  99.         case SENDTOBACK:        Dispatch((*ObjectH)->selectList,message,(*ObjectH)->objectList);        break;
  100.         case CLRSELECT:            Dispatch((*ObjectH)->selectList,message,NULL);        break;
  101.         case SELECT:            Dispatch((*ObjectH)->selectList,ADDOBJECT,ParmP);    break;
  102.         case UNSELECT:            Dispatch((*ObjectH)->selectList,DELOBJECT,ParmP);    break;
  103.         case ADDOBJECT:        
  104.         case DELOBJECT:            Dispatch((*ObjectH)->objectList,message,ParmP);     break;
  105.  
  106.          case IDLE:                Dispatch((*ObjectH)->activeText,message,NULL);        break;
  107.          case GETTOOL:            *ParmP = (long) (*ObjectH)->curTool;                    break;
  108.         case SETACTIVETEXT:        Dispatch((*ObjectH)->activeText,DEACTIVATE,NULL);
  109.                                 (*ObjectH)->activeText =  ParmP;        
  110.                                 Dispatch((*ObjectH)->activeText,ACTIVATE,NULL);    break;
  111.         case CLRACTIVETEXT:        (*ObjectH)->activeText = NULL;                            break;
  112.         default:                DrawObjectDispatch(ObjectH,message,ParmP);        break;
  113. }    }
  114.  
  115.  
  116. /*------------------------------------------------------------------*/
  117. DrawPanelHandle NewDrawPanel(ObjectHandle WindowObject);
  118. DrawPanelHandle NewDrawPanel(WindowObject)
  119. ObjectHandle WindowObject;
  120. {
  121.     DrawPanelHandle obj;
  122.     
  123.     obj = _GetHandleToRecord(DrawPanelRec);
  124.     NullOutHandle(obj);
  125.     (*obj)->port = (*WindowObject)->port;
  126.     (*obj)->class = DRAWPANEL;
  127.     (*obj)->dispatch = DrawPanelDispatch;
  128.     (*obj)->bounds = (*WindowObject)->bounds;
  129.     (*obj)->curTool = POINTER;
  130.     (*obj)->curPat = GRAY;
  131.     (*obj)->curWeight = LINEWT1;
  132.     New(LIST,NULL,&(*obj)->objectList);
  133.     New(LIST,NULL,&(*obj)->selectList);
  134.     (*obj)->drawState.penSize =  1;
  135.     (*obj)->drawState.penPat = BLACKPAT;
  136.     (*obj)->drawState.fillPat = GRAYPAT;
  137.      return(obj);
  138.  
  139.  }
  140. /*------------------------------------------------------------------*/
  141. static Point where = {90,90};
  142.  
  143. void Save(ObjectH,ParmP)
  144. DrawPanelHandle ObjectH;
  145. LPtr ParmP;
  146. {
  147.     FileHeaderPtr headerP;
  148.     Handle h;
  149.     long DoSaveAs;
  150.     SFReply         reply;        
  151.     Str255 fName;
  152.     
  153.     if (DoSaveAs = *ParmP) (*ObjectH)->fileVol = 0;        /* no known vol -> untitled file */
  154.     GetWTitle((*ObjectH)->port,fName);
  155.     
  156.     if ((*ObjectH)->fileVol)
  157.     {
  158.         reply.good = true;
  159.     }
  160.     else 
  161.     {
  162.         SFPutFile(where,"\pSave the document as:",fName,NULL,&reply);
  163.     }
  164.     if (reply.good)
  165.     {
  166.         h = _GetHandleToRecord(FileHeaderRec);
  167.         HLock(h); headerP = *h;
  168.         headerP->fileVol = (*ObjectH)->fileVol = reply.vRefNum;
  169.         StrCopy(reply.fName,headerP->fName);
  170.         SetWTitle((*ObjectH)->port,reply.fName);
  171.         headerP->curTool = (*ObjectH)->curTool;
  172.         headerP->curPat = (*ObjectH)->curPat;
  173.         headerP->curWeight = (*ObjectH)->curWeight;
  174.         headerP->drawState = (*ObjectH)->drawState;
  175.         headerP->wRect = GetWindowRect((*ObjectH)->port);
  176.         Dispatch((*ObjectH)->objectList,GETSIZE,&headerP->nObjects);
  177.         HUnlock(h);
  178.         Dispatch((*ObjectH)->objectList,SETLEN,h);
  179.         Dispatch((*ObjectH)->objectList,PACK,h);
  180.         WriteHandleToFile(h,&reply);
  181.     }
  182.     
  183. }
  184. /*------------------------------------------------------------------*/
  185. void Load(ObjectH,inP)
  186. DrawPanelHandle ObjectH;
  187. LPtr inP;
  188. {
  189.     FileHeaderPtr headerP;
  190.     Handle h = (Handle) inP;
  191.     long nObjects;
  192.     Rect dummyRect;
  193.     int i;
  194.     IPtr p;
  195.     int class;
  196.     ObjectHandle NewObject;
  197.     
  198.     HLock(h); headerP = *h;
  199.  
  200.      (*ObjectH)->curTool = headerP->curTool;
  201.     (*ObjectH)->curPat = headerP->curPat;
  202.     (*ObjectH)->curWeight = headerP->curWeight;
  203.     (*ObjectH)->drawState = headerP->drawState;
  204.     (*ObjectH)->fileVol = headerP->fileVol;
  205.     SetWTitle((*ObjectH)->port,headerP->fName);
  206.     nObjects = headerP->nObjects;
  207.     SetRect(&dummyRect,0,0,1,1);
  208.     p = (Ptr) headerP + sizeof(FileHeaderRec);
  209.     
  210.     for (i = 0; i < nObjects ; i++)
  211.     {
  212.         class = *(int *) p;
  213.         New(class,&dummyRect,&NewObject);
  214.         Dispatch(NewObject,UNPACK,&p);
  215.         Dispatch((*ObjectH)->objectList,ADDOBJECT,NewObject);
  216.         if (BitTst(&(*NewObject)->attributes,SelectedBit))
  217.         {
  218.             Dispatch(NewObject,SELECT,NULL);
  219.             Dispatch((*ObjectH)->selectList,ADDOBJECT,NewObject);
  220.         }
  221.     }    
  222.     InvalRect(&(*ObjectH)->bounds);
  223.     HUnlock(h);
  224.     MoveWindow ((*ObjectH)->port,headerP->wRect.left,headerP->wRect.top,TRUE);
  225.     SizeWindow ((*ObjectH)->port,Width(headerP->wRect),Height(headerP->wRect),TRUE);
  226.     DisposeHandle(h);
  227.     
  228. }
  229. /*------------------------------------------------------------------*/
  230. void Dispose(ObjectH)
  231. DrawPanelHandle ObjectH;
  232. {
  233.     long KillListAndContents = 1, KillListOnly = 2;
  234.  
  235.     Dispatch((*ObjectH)->objectList,DISPOSE,&KillListAndContents);
  236.     Dispatch((*ObjectH)->selectList,DISPOSE,&KillListOnly);
  237.     DisposeHandle(ObjectH);
  238. }
  239. /*------------------------------------------------------------------*/
  240. void MouseDown(ObjectH)
  241. DrawPanelHandle ObjectH;
  242. {
  243.     Point pt;
  244.     ObjectHandle objectH;
  245.     long args[2];
  246.     
  247.     GetMouse(&pt);
  248.     if (pt.h <= PALETTEWIDTH) ClickInPalette(ObjectH,pt);
  249.     else
  250.     {
  251.         args[0] = (long) &pt;
  252.         Dispatch((*ObjectH)->objectList,FIND,args);
  253.         objectH = (ObjectHandle) args[1];
  254.         if (objectH)    Dispatch(objectH,MOUSEDOWN,NULL);
  255.         else            OutlineNewObject(ObjectH,pt, (*ObjectH)->curTool);
  256.     }
  257.  }
  258. /*------------------------------------------------------------------*/
  259.  
  260. void KeyDown(ObjectH)
  261. DrawPanelHandle ObjectH;
  262. {
  263.     if ((*ObjectH)->curTool == TEXT)    
  264.     {    Dispatch((*ObjectH)->activeText,KEYDOWN,NULL);        }
  265.     else
  266.     {
  267.         extern EventRecord Event;
  268.                 char keyStroke;
  269.                 long KillOnlyElements = 1;
  270.             
  271.         keyStroke = Event.message & charCodeMask;
  272.         if (keyStroke == BACKSPACE)
  273.             Dispatch((*ObjectH)->selectList,DISPOSE,&KillOnlyElements);
  274.     }
  275. }
  276. /*------------------------------------------------------------------*/
  277. void Update(ObjectH)
  278. DrawPanelHandle ObjectH;
  279. {
  280.     PicHandle palette;
  281.     if (palette = GetPicture (ToolPaletteID))        DrawPic(0,0,palette);
  282.     InvertPaletteRect((*ObjectH)->curTool);
  283.     FramePaletteRect((*ObjectH)->curPat);
  284.     InvertPaletteRect((*ObjectH)->curWeight);
  285.     Dispatch((*ObjectH)->objectList,DRAW,NULL);
  286. }
  287. /*------------------------------------------------------------------*/
  288. /* to group:     delete all selected objects, 
  289. *                put them in a list, and add the list 
  290. /*------------------------------------------------------------------*/
  291.  
  292. void Group(ObjectH)
  293. DrawPanelHandle ObjectH;
  294. {
  295.     ObjectHandle group,obj;
  296.     int i;
  297.     long nElems;
  298.     
  299.     New(GROUP,NULL,&group);
  300.     Dispatch((*ObjectH)->selectList,GETSIZE,&nElems);
  301.     for (i = 0; i <  nElems; i++)
  302.     {
  303.         Dispatch((*ObjectH)->selectList,NEXT,&obj);
  304.         Dispatch((*ObjectH)->objectList,DELOBJECT,obj);
  305.         Dispatch(group,ADDOBJECT,obj);
  306.         Dispatch(obj,UNSELECT,NULL);
  307.     }
  308.     Dispatch((*ObjectH)->selectList,CLRSELECT,NULL);
  309.     Dispatch((*ObjectH)->objectList,ADDOBJECT,group);
  310.     Dispatch((*ObjectH)->selectList,ADDOBJECT,group);
  311.     Dispatch(group,SELECT,NULL);
  312.     Dispatch(group,INVAL,NULL);
  313. }    
  314. /*------------------------------------- send ungroup down to the group object ------------*/
  315. void Ungroup(ObjectH)
  316. DrawPanelHandle ObjectH;
  317. {
  318.     ObjectHandle obj;
  319.     long nElems;
  320.  
  321.     Dispatch((*ObjectH)->selectList,GETSIZE,&nElems);
  322.     if (nElems == 1)    /* only ungroup 1 at a time (an arbitrary restriction) */
  323.     {
  324.         Dispatch((*ObjectH)->selectList,NEXT,&obj);    /* get the one item */
  325.         if ((*obj)->class == GROUP)
  326.         {
  327.             Dispatch(obj,UNGROUP,NULL);
  328.         }
  329.     }
  330.     else SysBeep(4L);
  331. }
  332. /* ============================================================ */
  333. /*                                                                */
  334. /*                    SUPPORTING ROUTINES                            */
  335. /*                                                                */
  336. /* ============================================================ */
  337.  
  338. /* ------------------------------------------------------------ */
  339. /*                                                                */
  340. /*            OutlineNewObject                                    */
  341. /*                                                                */
  342. /*    This routines creates a new object.  First the mouse is        */
  343. /*    used to define the objects boundry rect.  Then the actual    */
  344. /*    object is created.                                            */
  345. /*                                                                */
  346. /*                                                                */
  347. /* ------------------------------------------------------------ */
  348.  
  349. void OutlineNewObject(ObjectH,startPt, curTool)
  350. DrawPanelHandle ObjectH;
  351. Point        startPt;
  352. short        curTool;
  353. {
  354.             ObjectHandle        NewObject;
  355.             Point                lastPos,curPos;
  356.             Rect                newRect,oldRect;
  357.  
  358.     SetRect(&newRect,startPt.h,startPt.v,startPt.h,startPt.v);
  359.     PenMode(patXor);        PenPat(gray);        PenSize(1,1);
  360.     
  361.     oldRect = newRect;
  362.     lastPos = curPos;
  363.     DrawOutline(newRect,curTool);
  364.     while (StillDown())
  365.     {
  366.         GetMouse(&curPos);
  367.         if ((curPos.h != lastPos.h) OR (curPos.v != lastPos.v))
  368.         {
  369.             
  370.             DrawOutline(oldRect,curTool);
  371.             DrawOutline(newRect,curTool);
  372.             oldRect = newRect;
  373.             lastPos = botRight(newRect) = curPos;
  374.  
  375.     }    }
  376.     DrawOutline(oldRect,curTool);
  377.  
  378.     PenPat(black);        PenMode(patCopy);
  379.     if (curTool == POINTER)
  380.     {
  381.         Dispatch((*ObjectH)->selectList,CLRSELECT,NULL);
  382.         Dispatch((*ObjectH)->objectList,SELECTRECT,&newRect);
  383.     }
  384.     else    
  385.     {
  386.         New(curTool,&newRect,&NewObject);
  387.  
  388.         if (NewObject)
  389.         {
  390.             Dispatch((*ObjectH)->selectList,CLRSELECT,NULL);
  391.             Dispatch((*ObjectH)->objectList,ADDOBJECT,NewObject);
  392.             Dispatch(NewObject,SELECT,NULL);
  393.             Dispatch((*ObjectH)->selectList,ADDOBJECT,NewObject);
  394.             (*ObjectH)->changed = true;
  395.         }
  396.     }
  397. }
  398. /*------------------------------------------------------------------*/
  399.  
  400. void DrawOutline(r,curTool)
  401. Rect r;
  402. int curTool;
  403. {            
  404.         if (curTool != LINE)            SortRect(&r);
  405.         
  406.         if (curTool == LINE)            DrawLine(topLeft(r),botRight(r));
  407.         else    if (curTool == OVAL)    FrameOval(&r);
  408.         else                            FrameRect(&r);
  409. }
  410.  
  411. /* ------------------------------------------------------------ */
  412. /*                                                                */
  413. /*            EDIT /  SELECT ALL Menu Item handler                */
  414. /*                                                                */
  415. /*        02/28/88    function created                        JMC    */
  416. /*                                                                */
  417. /* ------------------------------------------------------------ */
  418. void SelectAll(DrawPanelHandle ObjectH);
  419.  
  420. void SelectAll(ObjectH)
  421. DrawPanelHandle ObjectH;
  422.  
  423. {            
  424.         Dispatch((*ObjectH)->objectList,SELECT,NULL);
  425. }
  426.  
  427.  
  428. /*------------------------------------generic method-------------*/
  429. /*
  430. *    Function:            --    DragActiveObjects
  431. *
  432. *
  433. *    Date:                --    Feb. 20, 1989
  434. *    PoopDraw Version 1    --     Copyright FYI,1989 --   Adam Treister
  435. /*---------------------------------------------------------------*/
  436.  
  437. void DragActiveObjects(ObjectH)
  438. DrawPanelHandle ObjectH;
  439.  
  440. {
  441.     extern    EventRecord    Event;
  442.     
  443.             RgnHandle        TheDragRgn;
  444.             Point            startPoint;
  445.             long            endPoint;
  446.             Rect            prtRect;
  447.                 
  448.     TheDragRgn = NewRgn();            /* make the region to drag */
  449.     OpenRgn();                        
  450.     Dispatch((*ObjectH)->selectList,FRAME,NULL);
  451.     CloseRgn(TheDragRgn);
  452.             
  453.     startPoint = Event.where;
  454.     GlobalToLocal(&startPoint);
  455.     prtRect = (*ObjectH)->port->portRect;
  456.     InsetRect(&prtRect, 20, 20);
  457.     endPoint = DragGrayRgn(TheDragRgn, startPoint, &prtRect, &prtRect, 0, NULL);
  458.             
  459.     Dispatch((*ObjectH)->selectList, MOVE,&endPoint);        /* move them all */
  460.     DisposeRgn(TheDragRgn);
  461.     (*ObjectH)->changed = true;
  462. }
  463.  
  464. /*------------------------------------------------------------------*/
  465.  
  466. /********************************************************************/
  467.  
  468. void SetFill(ObjectH,ParmP)
  469. DrawPanelHandle ObjectH;
  470. LPtr ParmP;
  471. {
  472.     long ct;
  473.     
  474.     Dispatch((*ObjectH)->selectList,GETSIZE,&ct);
  475.     if (ct)
  476.     {    Dispatch((*ObjectH)->selectList,FILL,ParmP);    }
  477.     else
  478.         (*ObjectH)->drawState.fillPat = *(int *) ParmP;
  479.  
  480. }
  481. /*------------------------------------------------------------------*/
  482. void SetPenPat(ObjectH,ParmP)
  483. DrawPanelHandle ObjectH;
  484. LPtr ParmP;
  485. {
  486.     long ct;
  487.     
  488.     Dispatch((*ObjectH)->selectList,GETSIZE,&ct);
  489.     if (ct)
  490.     {    Dispatch((*ObjectH)->selectList,PENPAT,ParmP);    }
  491.     else
  492.         (*ObjectH)->drawState.penPat = *(int *) ParmP;
  493. }
  494. /*------------------------------------------------------------------*/
  495. void SetPenSize(ObjectH,ParmP)
  496. DrawPanelHandle ObjectH;
  497. LPtr ParmP;
  498. {
  499.     long ct;
  500.     
  501.     Dispatch((*ObjectH)->selectList,GETSIZE,&ct);
  502.     if (ct)
  503.     {    Dispatch((*ObjectH)->selectList,PENSIZE,ParmP);    }
  504.     else
  505.         (*ObjectH)->drawState.penSize = *(int *) ParmP;
  506. }
  507. /********************************************************************/
  508.  
  509.  
  510.  
  511. void ClickInPalette(ObjectH,pt)
  512. DrawPanelHandle ObjectH;
  513. Point            pt;
  514. {
  515.             int toolHit,curTool,message;
  516.             int pat;
  517.             
  518.     toolHit = ((pt.v-1) / PALETTEHEIGHT) + 1;
  519.     curTool = (*ObjectH)->curTool;
  520.     if (toolHit <= TEXT)
  521.     {
  522.         if (toolHit != curTool)
  523.         {
  524.             InvertPaletteRect(curTool);
  525.             InvertPaletteRect(toolHit);
  526.             (*ObjectH)->curTool = toolHit;
  527.             message = (toolHit == TEXT) ? ACTIVATE : DEACTIVATE;
  528.             Dispatch((*ObjectH)->activeText, message,NULL);
  529.         }
  530.     }
  531.     else if (toolHit <= WHITE)
  532.     {
  533.         if (toolHit != (*ObjectH)->curPat)
  534.         {
  535.             FramePaletteRect((*ObjectH)->curPat);
  536.             FramePaletteRect((*ObjectH)->curPat = toolHit);
  537.             
  538.             switch (toolHit)
  539.             {
  540.                 case BLACK:        pat = BLACKPAT;        break;
  541.                 case DKGRAY:    pat = DKGRAYPAT;    break;
  542.                 case GRAY:        pat = GRAYPAT;        break;
  543.                 case LTGRAY:    pat = LTGRAYPAT;    break;
  544.                 case WHITE:        pat = WHITEPAT;        break;
  545.             }
  546.             message = (_OptionKeyDown(Event)) ? PENPAT : FILL;
  547.             Dispatch(ObjectH,message,&pat);
  548.         }    
  549.     }
  550.     else if (toolHit <= LINEWT3)
  551.     {
  552.         if (toolHit != (*ObjectH)->curWeight)
  553.         {
  554.             int weight;
  555.  
  556.             InvertPaletteRect((*ObjectH)->curWeight);
  557.             InvertPaletteRect((*ObjectH)->curWeight = toolHit);
  558.             switch (toolHit)
  559.             {
  560.                 case LINEWT0:    weight = 0;        break;
  561.                 case LINEWT1:    weight = 1;        break;
  562.                 case LINEWT2:    weight = 2;        break;
  563.                 case LINEWT3:    weight = 4;        break;
  564.             }
  565.             Dispatch(ObjectH,PENSIZE,&weight);
  566.         }
  567.     }
  568. }
  569. /*------------------------------------------------------------------*/
  570.  
  571. void InvertPaletteRect(tool)
  572. int tool;
  573. {
  574.     Rect r;
  575.     int top,bottom;
  576.     
  577.     --tool;
  578.     top = PALETTEHEIGHT * tool + 2;
  579.     bottom = top + PALETTEHEIGHT - 3;
  580.     SetRect(&r,2,top,PALETTEWIDTH-2,bottom);
  581.     InvertRect(&r);
  582. }
  583. /*------------------------------------------------------------------*/
  584.  
  585. void FramePaletteRect(tool)
  586. int tool;
  587. {
  588.     Rect r;
  589.     int top,bottom;
  590.     
  591.     --tool;
  592.     top = PALETTEHEIGHT * tool + 1;
  593.     bottom = top + PALETTEHEIGHT - 1;
  594.     SetRect(&r,1,top,PALETTEWIDTH-1,bottom);
  595.     PenSize(3,3);    PenMode(patXor);
  596.     FrameRect(&r);
  597.     PenNormal();
  598. }
  599.  
  600.